package multithread.thread.mychongrusuo;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * Created by xi on 2019/2/17.
 * 重入锁：1 计数器，2 如果计算器不为0，但是进入的是当前线程，不需要等待。
 *
 */
public class MyRepeatLock implements Lock{
    private boolean isLocked = false; //锁的标记，锁被那个线程锁着呢

    //要实现的功能，lock的时候，只有一个线程能拿到锁，其他线程等待，然后等第一个unlock了，其他线程恢复
    //lock，synchorinize,wait, 第一个线程不等待，其他线程都等待。
    // 1 只能允许一个线程执行 这个函数，这个时候，我们要使用synchronized，其他线程都堵塞住
    // 2 只有一个线程能通过，其他线程要等待wait wait,必须在synchorinzed快里面，公用通一个监视器对象。

    private int lockCount ;
    private Thread lockedBy;


    @Override
    public synchronized  void lock() {
        //来到这个线程，都等待，只有初始进来的不等待，其他的都等待
        Thread currentThread = Thread.currentThread(); // Thread-0
        while(isLocked && currentThread != lockedBy){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        lockCount ++;
        isLocked = true;
        lockedBy = currentThread;
    }

    @Override
    public synchronized void unlock() {
        if(lockedBy == Thread.currentThread()){ //只有锁的持有者才能释放
            lockCount --;
            if(lockCount ==0){
                isLocked = false;
                notify(); //通知其他线程恢复
            }
        }
    }

    @Override public void lockInterruptibly() throws InterruptedException {

    }

    @Override public boolean tryLock() {
        return false;
    }

    @Override public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }


    @Override public Condition newCondition() {
        return null;
    }
}
